/*
02-线性结构4 Pop Sequence
*/
/*
判断方法1：
1）出栈的顺序遵循着一个规律: 对于数据中第i个数来说，其后的数比它小的必须以递减顺序排列。
2）对于数据中第i个数来说，其后及其比它小的数的个数，要小于栈的容量

判断方法2：
直接拿一个栈去模拟
即如果出栈序列的当前元素已在栈中但不在栈顶，则出栈序列不合法，
否则压栈(若栈已满，则出栈序列不合法)直到出栈序列的当前元素位于栈顶，然后出栈，
考虑序列的下一个元素。
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Stack-Array ======================================*/
#ifndef StackElementType
#define StackElementType int
#endif

typedef struct Stack Stack;
struct Stack {
    StackElementType* data;
    int top;
    int capacity;
};

Stack* createStack(int capacity) {
    Stack* s = calloc(1, sizeof(Stack));
    s->data = calloc(capacity, sizeof(StackElementType));
    s->capacity = capacity;
    s->top = 0;
    return s;
}

void freeStack(Stack* stack) {
    free(stack->data);
    free(stack);
}

int isStackEmpty(Stack* s) {
    return s->top == 0;
}

int isStackFull(Stack* s) {
    return s->top >= s->capacity;
}

StackElementType peekFirst(Stack* s) {
    return s->data[s->top];
}

int pushStack(Stack* s, StackElementType value) {
    if (isStackFull(s)) {
        printf("Stack Full\n");
        return 0;
    }
    s->data[++(s->top)] = value;
    return 1;
}

StackElementType popStack(Stack* s) {
    return s->data[(s->top)--];
}

/* current ===================================================*/
// 读取待验证的数据到数组中
void read(int *data, int N) {
    for (int i=0; i<N; i++) {
        scanf("%d", &data[i]);
    }
}

// 验证是否合法，合法返回1，不合法返回0
int validate(int *data, int M, int N) {
    int result = 1;
    // 用栈模拟
    Stack *stack = createStack(M);
    // 用于判断某个数是否在栈中，inStack[i] == 1, 表示i在栈中； == 0 i不在栈中
    static int inStack[1000];
    memset(inStack, 0, sizeof(inStack));
    int no = 1; 
    for (int i=0; i<N; ) {
        // printf("i=%d, no=%d, p->top=%d, p->data[top]=%d\n", i, no, pstack->top, pstack->data[pstack->top]);
        // 栈序列的当前元素已在栈中
        int v = data[i];
        if (inStack[v]) {
            // 在栈顶出栈，不在栈顶，则出栈序列不合法
            if (!isStackEmpty(stack) && peekFirst(stack) == v) {
                popStack(stack);
                inStack[v] = 0;
            } else {
                result = 0;
                break;
            }
            i++;
        } else {
            // 不在栈中则压栈，若栈已满，则出栈序列不合法
            if (isStackFull(stack)) {
                result = 0;
                break;
            }
            pushStack(stack, no);
            inStack[no] = 1;
            no++;
        }
    }
    freeStack(stack);
    return result;
}

int main() {
    int M, N, K;
    scanf("%d %d %d", &M, &N, &K);
    int *data = (int*) malloc(sizeof(int)*N);

    for (int i=0; i<K; i++) {
        read(data, N);
        char* result = validate(data, M, N) ? "YES" : "NO";
        printf("%s\n", result);
    }
    free(data);
    return 0;
}
